home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gxobj.h < prev    next >
C/C++ Source or Header  |  1996-10-27  |  8KB  |  210 lines
  1. /* Copyright (C) 1995, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gxobj.h */
  20. /* Memory manager implementation structures for Ghostscript */
  21. #include "gxbitmap.h"
  22.  
  23. /* ================ Objects ================ */
  24.  
  25. /*
  26.  * Object headers come in a number of different varieties.
  27.  * All arise from the same basic form, which is
  28.     -l- -lmsize/mark/back-
  29.     -size-
  30.     -type/reloc-
  31.  * l (large) is a single bit.  The size of lmsize/mark/back, size, and type
  32.  * varies according to the environment.  On machines with N:16 segmented
  33.  * addressing, 16-bit ints, and no alignment requirement more severe than
  34.  * 2 bytes, we can fit an object header into 8 bytes by making the first
  35.  * two fields only 16 bits wide.  On all other machines, we let the
  36.  * lmsize/mark/back field be 1 bit shorter than a uint, and round the header
  37.  * size up to the next multiple of the most severe alignment restriction
  38.  * (4 or 8 bytes).  Miraculously, we can do all this without any case testing.
  39.  *
  40.  * The mark/back field is used for the mark during the marking phase of
  41.  * garbage collection, and for a back pointer value during the compaction
  42.  * phase.  Since we want to be able to collect local VM independently of
  43.  * global VM, we need two different distinguished mark values:
  44.  *    - For local objects that have not been traced and should be freed
  45.  *    (compacted out), we use 1...11 in the mark field (o_unmarked).
  46.  *    - For global objects that have not been traced but should be kept,
  47.  *    we use 1...10 in the mark field (o_untraced).
  48.  * Note that neither of these values is a possible real relocation value.
  49.  *
  50.  * The lmsize field of large objects overlaps mark and back, so we must
  51.  * handle these functions for large objects in some other way.
  52.  * Since large objects cannot be moved or relocated, we don't need the
  53.  * back field for them; we allocate 2 bits for the 3 mark values.
  54.  */
  55. /*
  56.  * The back pointer's meaning depends on whether the object is
  57.  * free (unmarked) or in use (marked):
  58.  *    - In free objects, the back pointer is an offset from the object
  59.  * header back to a chunk_head_t structure that contains the location
  60.  * to which all the data in this chunk will get moved; the reloc field
  61.  * contains the amount by which the following run of useful objects
  62.  * will be relocated downwards.
  63.  *    - In useful objects, the back pointer is an offset from the object
  64.  * back to the previous free object; the reloc field is not used (it
  65.  * overlays the type field).
  66.  * These two cases can be distinguished when scanning a chunk linearly,
  67.  * but when simply examining an object via a pointer, the chunk pointer
  68.  * is also needed.
  69.  */
  70. #define obj_flag_bits 1
  71. #define obj_mb_bits (arch_sizeof_int * 8 - obj_flag_bits)
  72. #define obj_ls_bits (obj_mb_bits - 2)
  73. #define o_unmarked (((uint)1 << obj_mb_bits) - 1)
  74. #define o_l_unmarked (o_unmarked & 3)
  75. #define o_set_unmarked_large(pp) (pp)->o_lmark = o_l_unmarked
  76. #define o_set_unmarked(pp)\
  77.   if ( (pp)->o_large ) o_set_unmarked_large(pp);\
  78.   else (pp)->o_smark = o_unmarked
  79. #define o_is_unmarked_large(pp) ((pp)->o_lmark == o_l_unmarked)
  80. #define o_is_unmarked(pp)\
  81.  ((pp)->o_large ? o_is_unmarked_large(pp) :\
  82.   ((pp)->o_smark == o_unmarked))
  83. #define o_untraced (((uint)1 << obj_mb_bits) - 2)
  84. #define o_l_untraced (o_untraced & 3)
  85. #define o_set_untraced(pp)\
  86.   if ( (pp)->o_large ) (pp)->o_lmark = o_l_untraced;\
  87.   else (pp)->o_smark = o_untraced
  88. #define o_is_untraced(pp)\
  89.  ((pp)->o_large ? (pp)->o_lmark == o_l_untraced :\
  90.   ((pp)->o_smark == o_untraced))
  91. #define o_marked 0
  92. #define o_mark_large(pp) (pp)->o_lmark = o_marked
  93. #define o_mark(pp)\
  94.   if ( (pp)->o_large ) o_mark_large(pp);\
  95.   else (pp)->o_smark = o_marked
  96. #define obj_back_shift obj_flag_bits
  97. #define obj_back_scale (1 << obj_back_shift)
  98. typedef struct obj_header_data_s {
  99.     union _f {
  100.       struct _h { unsigned large : 1; } h;
  101.       struct _l { unsigned _ : 1, lmark : 2, lsize : obj_ls_bits; } l;
  102.       struct _m { unsigned _ : 1, smark : obj_mb_bits; } m;
  103.       struct _b { unsigned _ : 1, back : obj_mb_bits; } b;
  104.     } f;
  105.     uint size;
  106.     union _t {
  107.       gs_memory_type_ptr_t type;
  108.       uint reloc;
  109.     } t;
  110. } obj_header_data_t;
  111.  
  112. /*
  113.  * Define the alignment modulus for aligned objects.  We assume all
  114.  * alignment values are powers of 2; we can avoid nested 'max'es that way.
  115.  * The final | is because back pointer values are divided by obj_back_scale,
  116.  * so objects must be aligned at least 0 mod obj_back_scale.
  117.  */
  118. #define obj_align_mod\
  119.   (((arch_align_long_mod - 1) | (arch_align_ptr_mod - 1) |\
  120.     (arch_align_double_mod - 1) | (align_bitmap_mod - 1) |\
  121.     (obj_back_scale - 1)) + 1)
  122. /* The only possible values for obj_align_mod are 4, 8, or 16.... */
  123. #if obj_align_mod == 4
  124. #  define log2_obj_align_mod 2
  125. #else
  126. #if obj_align_mod == 8
  127. #  define log2_obj_align_mod 3
  128. #else
  129. #if obj_align_mod == 16
  130. #  define log2_obj_align_mod 4
  131. #endif
  132. #endif
  133. #endif
  134. #define obj_align_mask (obj_align_mod-1)
  135. #define obj_align_round(siz)\
  136.   (uint)(((siz) + obj_align_mask) & -obj_align_mod)
  137. #define obj_size_round(siz)\
  138.   obj_align_round((siz) + sizeof(obj_header_t))
  139.  
  140. /* Define the real object header type, taking alignment into account. */
  141. struct obj_header_s {    /* must be a struct because of forward reference */
  142.     union _d {
  143.         obj_header_data_t o;
  144.         byte _pad[round_up(sizeof(obj_header_data_t), obj_align_mod)];
  145.     } d;
  146. };
  147.  
  148. /* Define some reasonable abbreviations for the fields. */
  149. #define o_large d.o.f.h.large
  150. #define o_lsize d.o.f.l.lsize
  151. #define o_lmark d.o.f.l.lmark
  152. #define o_back d.o.f.b.back
  153. #define o_smark d.o.f.m.smark
  154. #define o_size d.o.size
  155. #define o_type d.o.t.type
  156. #define o_nreloc d.o.t.reloc
  157.  
  158. /*
  159.  * The macros for getting the sizes of objects all take pointers to
  160.  * the object header, for use when scanning storage linearly.
  161.  */
  162. #define pre_obj_small_size(pp)\
  163.   ((pp)->o_size)
  164.  
  165. #if arch_sizeof_long > arch_sizeof_int
  166.  
  167.     /* Large objects need to use o_lsize. */
  168.  
  169. #define pre_obj_large_size(pp)\
  170.   (((ulong)(pp)->o_lsize << (arch_sizeof_int * 8)) + (pp)->o_size)
  171. #define pre_obj_set_large_size(pp, lsize)\
  172.   ((pp)->o_lsize = (lsize) >> (arch_sizeof_int * 8),\
  173.    (pp)->o_size = (uint)(lsize))
  174. #define pre_obj_contents_size(pp)\
  175.   ((pp)->o_large ? pre_obj_large_size(pp) : pre_obj_small_size(pp))
  176.  
  177. #else
  178.  
  179.     /* Large objects don't need to use o_lsize. */
  180.  
  181. #define pre_obj_large_size(pp)\
  182.   pre_obj_small_size(pp)
  183. #define pre_obj_set_large_size(pp, lsize)\
  184.   ((pp)->o_lsize = 0,\
  185.    (pp)->o_size = (lsize))
  186. #define pre_obj_contents_size(pp)\
  187.   pre_obj_small_size(pp)
  188.  
  189. #endif
  190.  
  191. #define pre_obj_rounded_size(pp)\
  192.   obj_size_round(pre_obj_contents_size(pp))
  193. #define pre_obj_next(pp)\
  194.   ((obj_header_t *)((byte *)(pp) + obj_align_round(\
  195.     pre_obj_contents_size(pp) + sizeof(obj_header_t) )))
  196.  
  197. /*
  198.  * Define the header that free objects point back to when relocating.
  199.  * Every chunk, including inner chunks, has one of these.
  200.  */
  201. typedef struct chunk_head_s {
  202.     byte *dest;            /* destination for objects */
  203. #if obj_align_mod > arch_sizeof_ptr
  204.     byte *_pad[obj_align_mod / arch_sizeof_ptr - 1];
  205. #endif
  206.     obj_header_t free;        /* header for a free object, */
  207.                     /* in case the first real object */
  208.                     /* is in use */
  209. } chunk_head_t;
  210.